package kzy.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fasterxml.jackson.core.JsonProcessingException;
import kzy.common.BaseContext;
import kzy.common.R;
import kzy.dto.DishDto;
import kzy.entiy.Dish;
import kzy.entiy.DishFlavor;
import kzy.entiy.SetmealDish;
import kzy.service.CategoryService;
import kzy.service.DishFlavorService;
import kzy.service.DishService;
import kzy.service.SetmealDishService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.*;
import java.util.concurrent.TimeUnit;

import static com.baomidou.mybatisplus.core.toolkit.ObjectUtils.isNotEmpty;

/**
 * @Author 大溪地
 * @create 2023年05月27日15:32
 */
@Slf4j

@RestController()
@RequestMapping("/dish")
public class dishController {
public static final 	Map<String,List<DishDto>> MAP_DISH_DTO = new HashMap<>();

	@Autowired
	DishService dishService;

	@Autowired
	CategoryService  categoryService;

	@Autowired
	DishFlavorService dishFlavorService;


	@Autowired
	SetmealDishService setmealDishService;

	@Autowired
	private RedisTemplate redisTemplate;
	/**
	 * 菜品添加
	 * @param request
	 * @param dishDto
	 * @return
	 */
	@PostMapping()
	public R<String> dish(HttpServletRequest request , @RequestBody DishDto dishDto){
//		获取 Session 里面的 id
		Long empId = (Long) request.getSession().getAttribute("employee");
//		传入 id 自动装配的class 会进行自动装配
		BaseContext.setCurrentId(empId);
		dishService.saveWithFlavor(dishDto);

		log.info(dishDto.toString());
		//		清理缓存
		Set keys = redisTemplate.keys("dish_*");
		if (keys != null) {
			redisTemplate.delete(keys);
		}
		return R.success("菜品添加成功");
	}


	/**
	 * 菜品分页查询
	 * @param page
	 * @param pageSize
	 * @param name
	 * @return
	 */
	@GetMapping("/page")
	public R<Page>  page(Integer page, Integer pageSize, String name ){
//		创建分页构造器对象
		Page pageInfo = new Page(page,pageSize);
//		2.根据页面提交用户名到数据查询数据  LambdaQueryWrapper  Lambda查询包装器
		LambdaQueryWrapper<Dish> queryWrapper =new LambdaQueryWrapper<>();
//		设置条件构造器 设置模糊查询  like 根据 name（名称）进行模糊查询
		queryWrapper.like(isNotEmpty(name),Dish::getName, name);
		//添加排序条件
		queryWrapper.orderByAsc(Dish::getSort);
		dishService.page(pageInfo, queryWrapper);
//		获得到原数据的list集合  categoryId
		List<Dish> records = pageInfo.getRecords();
		for (int i = 0; i < records.size(); i++) {
/*			循环遍历获取 菜品的类型id  使用该类型id 到 categoryService（类型Service）里面进行（getById  根据id）查找
			再获取该category（类型）的 name（名称）再把这个 name（名称） 设置到records.get(i).setCategoryName
			就是 Dish（类型）里面 的CategoryName（类型名称里面）*/
			records.get(i).setCategoryName((categoryService.getById(records.get(i).getCategoryId())).getName());
		}
//		返回分页查询
		return R.success(pageInfo);
	}

	/**
	 * 修改菜品回写数据
	 */
	@GetMapping("/{id}")
	public  R<Dish>  modifyDishesWriteBackData(@PathVariable("id") Long id ){
//		根据传入的id查询菜品信息
		Dish dish = dishService.getById(id);
		// .根据页面提交用户名到数据查询数据  LambdaQueryWrapper  Lambda查询包装器
		LambdaQueryWrapper<DishFlavor> queryWrapper =new LambdaQueryWrapper<>();
//		设置条件构造器 设置模糊查询  eq 根据 name（名称）条件查询
		queryWrapper.eq(DishFlavor::getDishId, id);
//		执行 DishId等于 id（菜品对应的口味数据）条件语句 并且得到list结果
		List<DishFlavor> list = dishFlavorService.list(queryWrapper);
//		将list结果添加到前面查询的dish 菜品信息中
		dish.setFlavors(list);
//		将 带有完整信息的 dish 返回给前端页面
		//		清理缓存
		Set keys = redisTemplate.keys("dish_*");
		if (keys != null) {
			redisTemplate.delete(keys);
		}
		return R.success(dish);

	}


	/**
	 * 更新菜品数据
	 * @param request
	 * @param dishDto
	 * @return
	 */
	@PutMapping()
	public R<String> updateDish(HttpServletRequest request , @RequestBody DishDto dishDto){
//		获取 Session 里面的 id
		Long empId = (Long) request.getSession().getAttribute("employee");
//		传入 id 自动装配的class 会进行自动装配
		BaseContext.setCurrentId(empId);
//		调用我们自己写的 修改菜品的方法 这个方法里面会更新菜品数据 然后先删除味道数据 然后再添加上菜品数据
		dishService.updateDish(dishDto);
//		清理缓存
		Set keys = redisTemplate.keys("dish_*");
		if (keys != null) {
			redisTemplate.delete(keys);
		}
		return R.success("菜品添加成功");
	}


	/**
	 * 禁用或者启用菜品  其实还要查询是否绑定了套餐 等会在做
	 * @param code  code 为 0 表示要禁用 code为1 表示要启用
	 * @return
	 */
	@PostMapping("/status/{code}")
	public R<String> status(HttpServletRequest request ,@PathVariable("code") Integer code ,Long[] ids){
		for (int i = 0; i < ids.length; i++) {

			//		先使用id去查询 dish的数据
			Dish dish = dishService.getById(ids[i]);
//		设置 菜品启用或者禁用的 Status 代码  0禁用 1启用
			dish.setStatus(code);
//		获取 Session 里面的 id
			Long empId = (Long) request.getSession().getAttribute("employee");
//		传入 id 自动装配的class 会进行自动装配
			BaseContext.setCurrentId(empId);
//		code==0表示要禁用
			if(code==0){
				dishService.updateById(dish);
			}
//		code==1表示要启用
			else if(code==1){
				dishService.updateById(dish);
			}
		}
//		清理缓存
		Set keys = redisTemplate.keys("dish_*");
		if (keys != null) {
			redisTemplate.delete(keys);
		}
		return R.success("修改成功");
	}


	/**
	 * 删除 菜品  这个也要查询 套餐 查看是否能够删除 等会做
	 * @param ids
	 * @return
	 */
	@DeleteMapping()
	public R<String> deleteDishes(Long[] ids){

		for (Long id : ids) {
			dishService.removeById(id);
			MAP_DISH_DTO.remove(id);
		}
		//		清理缓存
		Set keys = redisTemplate.keys("dish_*");
		if (keys != null) {
			redisTemplate.delete(keys);
		}
		return R.success("删除成功");
	}

	/**
	 * 获取所有的菜品信息
	 * @param categoryId
	 * @return
	 */
	@GetMapping("/list")
	public R<List<DishDto>> list(Long categoryId) throws JsonProcessingException {
		List<DishDto> dishDtosList = null;
		String key = "dish_"+categoryId + "_" + "_1";
		//判断redis中是否有菜品数据，如果有则直接返回。
		String value = (String) redisTemplate.opsForValue().get(key);
		if (value != null ) {
			if(MAP_DISH_DTO.get(value)!=null){
				return R.success(MAP_DISH_DTO.get(value));

			}
		}

		LambdaQueryWrapper<Dish> queryWrapper =new LambdaQueryWrapper<>();
		//设置条件构造器 设置模糊查询  eq 根据 categoryId（类型）条件查询
		queryWrapper.eq (isNotEmpty(categoryId), Dish::getCategoryId, categoryId);
//		执行 DishId等于 id（菜品对应的口味数据）条件语句 并且得到list结果
		queryWrapper.orderByAsc(Dish::getSort);
		List<Dish> dishlist = dishService.list(queryWrapper);
		 dishDtosList =new ArrayList<>();
		for (int i = 0; i < dishlist.size(); i++) {
			DishDto dishDto=new DishDto();
			BeanUtils.copyProperties(dishlist.get(i), dishDto );
			dishDtosList.add(dishDto);
		}

		for (DishDto dishDto : dishDtosList) {
			LambdaQueryWrapper<DishFlavor> queryWrapper2 = new LambdaQueryWrapper<>();
//		设置条件构造器 设置模糊查询  eq 根据 name（名称）条件查询
			queryWrapper2.eq(DishFlavor::getDishId, dishDto.getId());
//		执行 DishId等于 id（菜品对应的口味数据）条件语句 并且得到list结果
			List<DishFlavor> list = dishFlavorService.list(queryWrapper2);
			dishDto.setFlavors(list);
		}
//		添加缓存数据到ListDishDto里面去
		MAP_DISH_DTO.put(key,dishDtosList);
//		如果 redis 查询 kye  返回值为 null 那么就先查询数据  然后添加到redis 菜品缓存里面
		redisTemplate.opsForValue().set(key,key,60, TimeUnit.MINUTES);
//		返回数据
		return R.success(dishDtosList);
	}




}
